<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<title>popot-2.01: example-002.cc</title>

<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="doxygen.css" rel="stylesheet" type="text/css" />

<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="search/search.js"></script>
<script type="text/javascript">
  $(document).ready(function() { searchBox.OnSelectItem(0); });
</script>

</head>
<body>
<div id="top"><!-- do not remove this div! -->


<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  
  
  <td style="padding-left: 0.5em;">
   <div id="projectname">popot-2.01
   
   </div>
   
  </td>
  
  
  
 </tr>
 </tbody>
</table>
</div>

<!-- Generated by Doxygen 1.7.5 -->
<script type="text/javascript">
var searchBox = new SearchBox("searchBox", "search",false,'Search');
</script>
  <div id="navrow1" class="tabs">
    <ul class="tablist">
      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
      <li><a href="namespaces.html"><span>Namespaces</span></a></li>
      <li><a href="annotated.html"><span>Classes</span></a></li>
      <li><a href="files.html"><span>Files</span></a></li>
      <li><a href="examples.html"><span>Examples</span></a></li>
      <li>
        <div id="MSearchBox" class="MSearchBoxInactive">
        <span class="left">
          <img id="MSearchSelect" src="search/mag_sel.png"
               onmouseover="return searchBox.OnSearchSelectShow()"
               onmouseout="return searchBox.OnSearchSelectHide()"
               alt=""/>
          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)" 
               onblur="searchBox.OnSearchFieldFocus(false)" 
               onkeyup="searchBox.OnSearchFieldChange(event)"/>
          </span><span class="right">
            <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
          </span>
        </div>
      </li>
    </ul>
  </div>
</div>
<div class="header">
  <div class="headertitle">
<div class="title">example-002.cc</div>  </div>
</div>
<div class="contents">
<div class="fragment"><pre class="fragment"><span class="comment">// In this example, we show how ones can define its own problem with a PSO</span>
<span class="comment">// The problem we try to solve is optimizing a Multilayer Perceptron to detect if a number is odd or even</span>
<span class="comment">// The input is represented by 7 segments indexed the following way</span>
<span class="comment">//         ----- 0 -----</span>
<span class="comment">//         |           |</span>
<span class="comment">//         5           1</span>
<span class="comment">//         |           |</span>
<span class="comment">//         ----- 6 -----</span>
<span class="comment">//         |           |</span>
<span class="comment">//         4           2</span>
<span class="comment">//         |           |</span>
<span class="comment">//         ----- 3 -----</span>
<span class="comment">// Therefore, we code :</span>
<span class="comment">//   = [ 6 5 4 3 2 1 0]  &lt;- Index of the segments</span>
<span class="comment">// 0 = [ 0 1 1 1 1 1 1] ; 0x3F</span>
<span class="comment">// 1 = [ 0 0 0 0 1 1 0] ; 0x06</span>
<span class="comment">// 2 = [ 1 0 1 1 0 1 1] ; 0x5B</span>
<span class="comment">// 3 = [ 1 0 0 1 1 1 1] ; 0x4F</span>
<span class="comment">// 4 = [ 1 1 0 0 1 1 0] ; 0x66</span>
<span class="comment">// 5 = [ 1 1 0 1 1 0 1] ; 0x6D</span>
<span class="comment">// 6 = [ 1 1 1 1 1 0 1] ; 0x7D</span>
<span class="comment">// 7 = [ 0 0 0 0 1 1 1] ; 0x07</span>
<span class="comment">// 8 = [ 1 1 1 1 1 1 1] ; 0x7F</span>
<span class="comment">// 9 = [ 1 1 0 1 1 1 1] ; 0x6F</span>
<span class="comment">// In the code below, these are stored in inputs_mlp in the order : 0 1 2 3 4 5 6 ; 0 1 2 3 4 5 6 ....</span>

<span class="preprocessor">#include &lt;stdio.h&gt;</span>
<span class="preprocessor">#include &lt;cmath&gt;</span>
<span class="preprocessor">#include &lt;list&gt;</span>

<span class="comment">// We first define the generator of random numbers</span>
<span class="preprocessor">#include &quot;<a class="code" href="rng__generators_8h.html">rng_generators.h</a>&quot;</span>
<span class="keyword">typedef</span> popot::rng::CRNG RNG_GENERATOR;

<span class="preprocessor">#include &quot;<a class="code" href="popot_8h.html">popot.h</a>&quot;</span>


<span class="comment">// Define our problem</span>
<span class="comment">// We define it as a MLP tested on our dataset</span>
<span class="keyword">class </span>MLPClassifier
{
<span class="keyword">public</span>:
  <span class="keyword">const</span> <span class="keywordtype">size_t</span> nb_inputs;
  <span class="keyword">const</span> <span class="keywordtype">size_t</span> nb_outputs;
  <span class="keyword">const</span> <span class="keywordtype">size_t</span> nb_hidden;
  <span class="keyword">const</span> <span class="keywordtype">size_t</span> nb_digits;

  <span class="keyword">const</span> <span class="keywordtype">size_t</span> nb_parameters;<span class="comment">// = (nb_inputs+1)*nb_hidden + (nb_hidden+1)*nb_outputs;</span>
  <span class="keywordtype">int</span> *hexa_codes;
  <span class="keywordtype">int</span> *inputs_mlp;

  MLPClassifier(<span class="keywordtype">void</span>) : 
    nb_inputs(7), nb_outputs(1), nb_hidden(4), nb_digits(10),
    nb_parameters((nb_inputs+1)*nb_hidden + (nb_hidden+1)*nb_outputs)
  {
    hexa_codes = <span class="keyword">new</span> <span class="keywordtype">int</span>[nb_digits];
    hexa_codes[0] = 0x3F;
    hexa_codes[1] = 0x06;
    hexa_codes[2] = 0x5B;
    hexa_codes[3] = 0x4F;
    hexa_codes[4] = 0x66;
    hexa_codes[5] = 0x6D;
    hexa_codes[6] = 0x7D;
    hexa_codes[7] = 0x07;
    hexa_codes[8] = 0x7F;
    hexa_codes[9] = 0x6F;

    inputs_mlp = <span class="keyword">new</span> <span class="keywordtype">int</span>[nb_inputs*nb_digits];
    <span class="keywordtype">size_t</span> y;
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> x = 0 ; x &lt; nb_digits ; ++x)
      {
        y = hexa_codes[x];
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; nb_inputs ; ++i)
          {
            inputs_mlp[nb_inputs*x + i] = (y &amp; 0x01);
            y = y &gt;&gt; 1;
          }
      }
  }

  ~MLPClassifier(<span class="keywordtype">void</span>)
  {
    <span class="keyword">delete</span>[] hexa_codes;
    <span class="keyword">delete</span>[] inputs_mlp;
  }

  <span class="keywordtype">double</span> get_lbound(<span class="keywordtype">size_t</span> index)
  {  
    <span class="keywordflow">return</span> -10;
  }

  <span class="keywordtype">double</span> get_ubound(<span class="keywordtype">size_t</span> index)
  {    
    <span class="keywordflow">return</span> 10;
  }

  <span class="keywordtype">void</span> display_digits(std::vector&lt;int&gt; &amp;list_digits)
  {
    <span class="keywordflow">if</span>(list_digits.size() == 0)
      {
        printf(<span class="stringliteral">&quot;Nothing to display .. \n&quot;</span>);
        <span class="keywordflow">return</span>;
      }
    <span class="comment">// We want to display several digits on a row under their 7 segments format</span>
    <span class="comment">// We therefore display one after the other the rows for all the digits</span>

    <span class="comment">// Horizontal segments span 13 characters</span>
    <span class="comment">// Vertical segments span 3 characters</span>
    <span class="keywordtype">size_t</span> span_horiz = 13;
    <span class="keywordtype">size_t</span> span_vert = 3;
    <span class="keywordtype">size_t</span> space_digit = 3;

    <span class="comment">// Segment 0</span>
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; list_digits.size() ; ++i)
      {
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; span_horiz ; ++j)
          {
            <span class="keywordflow">if</span>(inputs_mlp[list_digits[i]*nb_inputs+0])
              printf(<span class="stringliteral">&quot;-&quot;</span>);
            <span class="keywordflow">else</span>
              printf(<span class="stringliteral">&quot; &quot;</span>);
          }
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; space_digit ; ++j)
          printf(<span class="stringliteral">&quot; &quot;</span>);
      }
    printf(<span class="stringliteral">&quot;\n&quot;</span>);
    <span class="comment">// Segments 5 and 1</span>
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; span_vert ; ++i)
      {
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; list_digits.size() ; ++j)
          {
            <span class="keywordflow">if</span>(inputs_mlp[list_digits[j]*nb_inputs+5])
              printf(<span class="stringliteral">&quot;|&quot;</span>);
            <span class="keywordflow">else</span>
              printf(<span class="stringliteral">&quot; &quot;</span>);
            <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> k = 0 ; k &lt; span_horiz - 2 ; ++k)
              printf(<span class="stringliteral">&quot; &quot;</span>);
            <span class="keywordflow">if</span>(inputs_mlp[list_digits[j]*nb_inputs+1])
              printf(<span class="stringliteral">&quot;|&quot;</span>);
            <span class="keywordflow">else</span>
              printf(<span class="stringliteral">&quot; &quot;</span>);
            <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> k = 0 ; k &lt; space_digit ; ++k)
              printf(<span class="stringliteral">&quot; &quot;</span>);
          }
        printf(<span class="stringliteral">&quot;\n&quot;</span>);
      }

    <span class="comment">// Segment 6</span>
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; list_digits.size() ; ++i)
      {
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; span_horiz ; ++j)
          {
            <span class="keywordflow">if</span>(inputs_mlp[list_digits[i]*nb_inputs+6])
              printf(<span class="stringliteral">&quot;-&quot;</span>);
            <span class="keywordflow">else</span>
              printf(<span class="stringliteral">&quot; &quot;</span>);
          }
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; space_digit ; ++j)
          printf(<span class="stringliteral">&quot; &quot;</span>);
      }
    printf(<span class="stringliteral">&quot;\n&quot;</span>);
    <span class="comment">// Segments 4 2</span>
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; span_vert ; ++i)
      {
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; list_digits.size() ; ++j)
          {
            <span class="keywordflow">if</span>(inputs_mlp[list_digits[j]*nb_inputs+4])
              printf(<span class="stringliteral">&quot;|&quot;</span>);
            <span class="keywordflow">else</span>
              printf(<span class="stringliteral">&quot; &quot;</span>);
            <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> k = 0 ; k &lt; span_horiz - 2 ; ++k)
              printf(<span class="stringliteral">&quot; &quot;</span>);
            <span class="keywordflow">if</span>(inputs_mlp[list_digits[j]*nb_inputs+2])
              printf(<span class="stringliteral">&quot;|&quot;</span>);
            <span class="keywordflow">else</span>
              printf(<span class="stringliteral">&quot; &quot;</span>);
            <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> k = 0 ; k &lt; space_digit ; ++k)
              printf(<span class="stringliteral">&quot; &quot;</span>);
          }
        printf(<span class="stringliteral">&quot;\n&quot;</span>);
      }
    <span class="comment">// Segment 3</span>
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; list_digits.size() ; ++i)
      {
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; span_horiz ; ++j)
          {
            <span class="keywordflow">if</span>(inputs_mlp[list_digits[i]*nb_inputs+3])
              printf(<span class="stringliteral">&quot;-&quot;</span>);
            <span class="keywordflow">else</span>
              printf(<span class="stringliteral">&quot; &quot;</span>);
          }
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; space_digit ; ++j)
          printf(<span class="stringliteral">&quot; &quot;</span>);
      }

    printf(<span class="stringliteral">&quot;\n&quot;</span>);
  }

  <span class="keywordtype">double</span> transfer_function(<span class="keywordtype">double</span> x)
  {
    <span class="comment">// We use a sigmoidal transfer function</span>
    <span class="keywordflow">return</span> 1.0 / (1.0 + exp(-x));
  }

  <span class="keywordtype">double</span> compute_output(<span class="keywordtype">int</span> input_index, <span class="keywordtype">double</span> * params)
  {
    <span class="keywordtype">double</span> act_input[nb_inputs];
    <span class="keywordtype">double</span> act_hidden[nb_hidden];
    <span class="keywordtype">double</span> act_output;

    <span class="comment">// Set up the input</span>
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; nb_inputs ; ++i)
      act_input[i] = inputs_mlp[nb_inputs * input_index + i];

    <span class="comment">// Compute the activity of the hidden nodes</span>
    <span class="keywordtype">size_t</span> params_index = 0;
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; nb_hidden ; ++i)
      {
        act_hidden[i] = params[params_index++];
        <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; nb_inputs ; ++j)
          {
            act_hidden[i] += params[params_index++] * act_input[j];
          }
        <span class="comment">// Apply the transfer function</span>
        act_hidden[i] = transfer_function(act_hidden[i]);
      }
    <span class="comment">// Compute the activity of the output node</span>
    act_output = params[params_index++];
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> j = 0 ; j &lt; nb_hidden ; ++j)
      act_output += params[params_index++] * act_hidden[j];
    act_output = transfer_function(act_output);

    <span class="keywordflow">return</span> act_output;
  }

  <span class="keywordtype">bool</span> stop(<span class="keywordtype">double</span> fitness, <span class="keywordtype">int</span> epoch)
  {
    <span class="keywordflow">return</span> (fitness &lt;= 1e-4) || (epoch &gt;= 1000);
  }

  <span class="keywordtype">double</span> evaluate(<span class="keywordtype">double</span> * params)
  {
    <span class="keywordtype">double</span> fitness = 0.0;
    <span class="keywordtype">double</span> act_output;
    <span class="comment">// Test over all the inputs</span>
    <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> k = 0 ; k &lt; nb_digits ; ++k)
      {
        act_output = compute_output(k, params);

        fitness += pow(act_output - (k%2),2.0);
      }
    <span class="keywordflow">return</span> fitness;
  }
};

<span class="comment">// Let&#39;s typedef the problem so that the following is identical to example-001</span>
<span class="keyword">typedef</span> MLPClassifier Problem;
<span class="keyword">typedef</span> popot::algorithm::ParticleSPSO::VECTOR_TYPE TVector;

<span class="comment">// **************************************** //</span>
<span class="comment">// ************** Main ******************** //</span>
<span class="comment">// **************************************** //</span>

<span class="keywordtype">int</span> main(<span class="keywordtype">int</span> argc, <span class="keywordtype">char</span>* argv[]) {

  RNG_GENERATOR::rng_srand();
  RNG_GENERATOR::rng_warm_up();

  <span class="comment">// Create an instance of the problem</span>
  Problem p;

  <span class="comment">// For testing</span>
  std::vector&lt;int&gt; odd_numbers;
  std::vector&lt;int&gt; even_numbers;
  std::vector&lt;int&gt; unclassified_numbers;
  <span class="keywordtype">double</span> * params = <span class="keyword">new</span> <span class="keywordtype">double</span>[p.nb_parameters];

  <span class="comment">// Let&#39;s create our swarm</span>
  std::cout &lt;&lt; <span class="stringliteral">&quot; Nb params :&quot;</span> &lt;&lt; p.nb_parameters &lt;&lt; std::endl;
  <span class="keyword">auto</span> algo = <a name="a0"></a><a class="code" href="namespacepopot_1_1algorithm.html#aafd0464056160a6c9e1cf33409e053f0">popot::algorithm::spso2011</a>(p.nb_parameters,
                                         [&amp;p] (<span class="keywordtype">size_t</span> index) -&gt; <span class="keywordtype">double</span> { <span class="keywordflow">return</span> p.get_lbound(index); },
                                         [&amp;p] (<span class="keywordtype">size_t</span> index) -&gt; <span class="keywordtype">double</span> { <span class="keywordflow">return</span> p.get_ubound(index); },
                                         [&amp;p] (<span class="keywordtype">double</span> fitness, <span class="keywordtype">int</span> epoch) -&gt; <span class="keywordtype">bool</span> { <span class="keywordflow">return</span> p.stop(fitness, epoch);},
                                         [&amp;p] (TVector &amp;pos) -&gt; <span class="keywordtype">double</span> { <span class="keywordflow">return</span> p.evaluate(pos.getValuesPtr());}
                                         );

  <span class="comment">// Let&#39;s generate the graph of the connections within the swarm</span>
  algo.generateGraph(<span class="stringliteral">&quot;connections.dot&quot;</span>);


  <span class="comment">// Test before learning :</span>
  printf(<span class="stringliteral">&quot;--------------------------------------------- \n Before learning : \n&quot;</span>);
  printf(<span class="stringliteral">&quot;Best fitness : %f \n&quot;</span>, algo.getBest().getFitness());
  
  <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; p.nb_parameters ; ++i)
    params[i] = algo.getBest().getPosition()[i];

  <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; p.nb_digits; ++i)
    {
      <span class="keywordflow">if</span>(p.compute_output(i, params) &gt;= 0.85)
        odd_numbers.push_back(i);
      <span class="keywordflow">else</span> <span class="keywordflow">if</span>(p.compute_output(i, params) &lt;= 0.15)
        even_numbers.push_back(i);
      <span class="keywordflow">else</span>
        unclassified_numbers.push_back(i);
    }

  printf(<span class="stringliteral">&quot;I classified %i numbers as EVEN : \n&quot;</span>, even_numbers.size());
  p.display_digits(even_numbers);
  printf(<span class="stringliteral">&quot;I classified %i numbers as ODD : \n&quot;</span>, odd_numbers.size());
  p.display_digits(odd_numbers);
  printf(<span class="stringliteral">&quot;I was not able to classify %i numbers : \n&quot;</span>, unclassified_numbers.size());
  p.display_digits(unclassified_numbers);  

  <span class="comment">// We now iterate the algorithm</span>
  algo.run();
  std::cout &lt;&lt; <span class="stringliteral">&quot;epoch : &quot;</span> &lt;&lt; algo.epoch &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">&quot;\n&quot;</span> &lt;&lt; std::endl;

  <span class="comment">// Test after learning :</span>
  printf(<span class="stringliteral">&quot;--------------------------------------------- \n After learning : \n&quot;</span>);
  printf(<span class="stringliteral">&quot;Best fitness : %f \n&quot;</span>, algo.getBest().getFitness());

  <span class="comment">// Get the best parameters</span>
  <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; p.nb_parameters ; ++i)
    params[i] = algo.getBest().getPosition()[i];

  <span class="comment">// And test them on our inputs</span>
  odd_numbers.clear();
  even_numbers.clear();
  unclassified_numbers.clear();
  <span class="comment">//for(int i = 0 ; i &lt; Problem::nb_digits ; ++i)</span>
  <span class="comment">//    printf(&quot;%i : %f \n&quot;, i, Problem::compute_output(i, params));</span>
  <span class="keywordflow">for</span>(<span class="keywordtype">size_t</span> i = 0 ; i &lt; p.nb_digits; ++i)
    {
      <span class="keywordflow">if</span>(p.compute_output(i, params) &gt;= 0.85)
        odd_numbers.push_back(i);
      <span class="keywordflow">else</span> <span class="keywordflow">if</span>(p.compute_output(i, params) &lt;= 0.15)
        even_numbers.push_back(i);
      <span class="keywordflow">else</span>
        unclassified_numbers.push_back(i);
    }

  printf(<span class="stringliteral">&quot;I classified %i numbers as EVEN : \n&quot;</span>, even_numbers.size());
  p.display_digits(even_numbers);
  printf(<span class="stringliteral">&quot;I classified %i numbers as ODD : \n&quot;</span>, odd_numbers.size());
  p.display_digits(odd_numbers);
  printf(<span class="stringliteral">&quot;I was not able to classify %i numbers : \n&quot;</span>, unclassified_numbers.size());
  p.display_digits(unclassified_numbers);
}

</pre></div> </div>
</div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
<a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(0)"><span class="SelectionMark">&#160;</span>All</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(1)"><span class="SelectionMark">&#160;</span>Classes</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(2)"><span class="SelectionMark">&#160;</span>Namespaces</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(3)"><span class="SelectionMark">&#160;</span>Files</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(4)"><span class="SelectionMark">&#160;</span>Functions</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(5)"><span class="SelectionMark">&#160;</span>Variables</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(6)"><span class="SelectionMark">&#160;</span>Typedefs</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(7)"><span class="SelectionMark">&#160;</span>Enumerations</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(8)"><span class="SelectionMark">&#160;</span>Enumerator</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(9)"><span class="SelectionMark">&#160;</span>Friends</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(10)"><span class="SelectionMark">&#160;</span>Defines</a></div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>



<hr class="footer"/><address class="footer"><small>
Generated by &#160;<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/>
</a> 1.7.5
</small></address>

</body>
</html>
